home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_array.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  29KB  |  936 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. '''Test the arraymodule.
  5.    Roger E. Masse
  6. '''
  7. import unittest
  8. from test import test_support
  9. from weakref import proxy
  10. import array
  11. import cStringIO
  12. import math
  13. tests = []
  14. typecodes = 'cubBhHiIlLfd'
  15.  
  16. class BadConstructorTest(unittest.TestCase):
  17.     
  18.     def test_constructor(self):
  19.         self.assertRaises(TypeError, array.array)
  20.         self.assertRaises(TypeError, array.array, spam = 42)
  21.         self.assertRaises(TypeError, array.array, 'xx')
  22.         self.assertRaises(ValueError, array.array, 'x')
  23.  
  24.  
  25. tests.append(BadConstructorTest)
  26.  
  27. class BaseTest(unittest.TestCase):
  28.     
  29.     def assertEntryEqual(self, entry1, entry2):
  30.         self.assertEqual(entry1, entry2)
  31.  
  32.     
  33.     def badtypecode(self):
  34.         return typecodes[(typecodes.index(self.typecode) + 1) % len(typecodes)]
  35.  
  36.     
  37.     def test_constructor(self):
  38.         a = array.array(self.typecode)
  39.         self.assertEqual(a.typecode, self.typecode)
  40.         self.assert_(a.itemsize >= self.minitemsize)
  41.         self.assertRaises(TypeError, array.array, self.typecode, None)
  42.  
  43.     
  44.     def test_len(self):
  45.         a = array.array(self.typecode)
  46.         a.append(self.example[0])
  47.         self.assertEqual(len(a), 1)
  48.         a = array.array(self.typecode, self.example)
  49.         self.assertEqual(len(a), len(self.example))
  50.  
  51.     
  52.     def test_buffer_info(self):
  53.         a = array.array(self.typecode, self.example)
  54.         self.assertRaises(TypeError, a.buffer_info, 42)
  55.         bi = a.buffer_info()
  56.         self.assert_(isinstance(bi, tuple))
  57.         self.assertEqual(len(bi), 2)
  58.         self.assert_(isinstance(bi[0], int))
  59.         self.assert_(isinstance(bi[1], int))
  60.         self.assertEqual(bi[1], len(a))
  61.  
  62.     
  63.     def test_byteswap(self):
  64.         a = array.array(self.typecode, self.example)
  65.         self.assertRaises(TypeError, a.byteswap, 42)
  66.         if a.itemsize in (1, 2, 4, 8):
  67.             b = array.array(self.typecode, self.example)
  68.             b.byteswap()
  69.             if a.itemsize == 1:
  70.                 self.assertEqual(a, b)
  71.             else:
  72.                 self.assertNotEqual(a, b)
  73.             b.byteswap()
  74.             self.assertEqual(a, b)
  75.         
  76.  
  77.     
  78.     def test_copy(self):
  79.         import copy as copy
  80.         a = array.array(self.typecode, self.example)
  81.         b = copy.copy(a)
  82.         self.assertNotEqual(id(a), id(b))
  83.         self.assertEqual(a, b)
  84.  
  85.     
  86.     def test_insert(self):
  87.         a = array.array(self.typecode, self.example)
  88.         a.insert(0, self.example[0])
  89.         self.assertEqual(len(a), 1 + len(self.example))
  90.         self.assertEqual(a[0], a[1])
  91.         self.assertRaises(TypeError, a.insert)
  92.         self.assertRaises(TypeError, a.insert, None)
  93.         self.assertRaises(TypeError, a.insert, 0, None)
  94.         a = array.array(self.typecode, self.example)
  95.         a.insert(-1, self.example[0])
  96.         self.assertEqual(a, array.array(self.typecode, self.example[:-1] + self.example[:1] + self.example[-1:]))
  97.         a = array.array(self.typecode, self.example)
  98.         a.insert(-1000, self.example[0])
  99.         self.assertEqual(a, array.array(self.typecode, self.example[:1] + self.example))
  100.         a = array.array(self.typecode, self.example)
  101.         a.insert(1000, self.example[0])
  102.         self.assertEqual(a, array.array(self.typecode, self.example + self.example[:1]))
  103.  
  104.     
  105.     def test_tofromfile(self):
  106.         a = array.array(self.typecode, 2 * self.example)
  107.         self.assertRaises(TypeError, a.tofile)
  108.         self.assertRaises(TypeError, a.tofile, cStringIO.StringIO())
  109.         f = open(test_support.TESTFN, 'wb')
  110.         
  111.         try:
  112.             a.tofile(f)
  113.             f.close()
  114.             b = array.array(self.typecode)
  115.             f = open(test_support.TESTFN, 'rb')
  116.             self.assertRaises(TypeError, b.fromfile)
  117.             self.assertRaises(TypeError, b.fromfile, cStringIO.StringIO(), len(self.example))
  118.             b.fromfile(f, len(self.example))
  119.             self.assertEqual(b, array.array(self.typecode, self.example))
  120.             self.assertNotEqual(a, b)
  121.             b.fromfile(f, len(self.example))
  122.             self.assertEqual(a, b)
  123.             self.assertRaises(EOFError, b.fromfile, f, 1)
  124.             f.close()
  125.         finally:
  126.             if not f.closed:
  127.                 f.close()
  128.             
  129.             test_support.unlink(test_support.TESTFN)
  130.  
  131.  
  132.     
  133.     def test_tofromlist(self):
  134.         a = array.array(self.typecode, 2 * self.example)
  135.         b = array.array(self.typecode)
  136.         self.assertRaises(TypeError, a.tolist, 42)
  137.         self.assertRaises(TypeError, b.fromlist)
  138.         self.assertRaises(TypeError, b.fromlist, 42)
  139.         self.assertRaises(TypeError, b.fromlist, [
  140.             None])
  141.         b.fromlist(a.tolist())
  142.         self.assertEqual(a, b)
  143.  
  144.     
  145.     def test_tofromstring(self):
  146.         a = array.array(self.typecode, 2 * self.example)
  147.         b = array.array(self.typecode)
  148.         self.assertRaises(TypeError, a.tostring, 42)
  149.         self.assertRaises(TypeError, b.fromstring)
  150.         self.assertRaises(TypeError, b.fromstring, 42)
  151.         b.fromstring(a.tostring())
  152.         self.assertEqual(a, b)
  153.         if a.itemsize > 1:
  154.             self.assertRaises(ValueError, b.fromstring, 'x')
  155.         
  156.  
  157.     
  158.     def test_repr(self):
  159.         a = array.array(self.typecode, 2 * self.example)
  160.         self.assertEqual(a, eval(repr(a), {
  161.             'array': array.array }))
  162.         a = array.array(self.typecode)
  163.         self.assertEqual(repr(a), "array('%s')" % self.typecode)
  164.  
  165.     
  166.     def test_str(self):
  167.         a = array.array(self.typecode, 2 * self.example)
  168.         str(a)
  169.  
  170.     
  171.     def test_cmp(self):
  172.         a = array.array(self.typecode, self.example)
  173.         self.assert_(a == 42 is False)
  174.         self.assert_(a != 42 is True)
  175.         self.assert_(a == a is True)
  176.         self.assert_(a != a is False)
  177.         self.assert_(a < a is False)
  178.         self.assert_(a <= a is True)
  179.         self.assert_(a > a is False)
  180.         self.assert_(a >= a is True)
  181.         as = array.array(self.typecode, self.smallerexample)
  182.         ab = array.array(self.typecode, self.biggerexample)
  183.         self.assert_(a == 2 * a is False)
  184.         self.assert_(a != 2 * a is True)
  185.         self.assert_(a < 2 * a is True)
  186.         self.assert_(a <= 2 * a is True)
  187.         self.assert_(a > 2 * a is False)
  188.         self.assert_(a >= 2 * a is False)
  189.         self.assert_(a == as is False)
  190.         self.assert_(a != as is True)
  191.         self.assert_(a < as is False)
  192.         self.assert_(a <= as is False)
  193.         self.assert_(a > as is True)
  194.         self.assert_(a >= as is True)
  195.         self.assert_(a == ab is False)
  196.         self.assert_(a != ab is True)
  197.         self.assert_(a < ab is True)
  198.         self.assert_(a <= ab is True)
  199.         self.assert_(a > ab is False)
  200.         self.assert_(a >= ab is False)
  201.  
  202.     
  203.     def test_add(self):
  204.         a = array.array(self.typecode, self.example) + array.array(self.typecode, self.example[::-1])
  205.         self.assertEqual(a, array.array(self.typecode, self.example + self.example[::-1]))
  206.         b = array.array(self.badtypecode())
  207.         self.assertRaises(TypeError, a.__add__, b)
  208.         self.assertRaises(TypeError, a.__add__, 'bad')
  209.  
  210.     
  211.     def test_iadd(self):
  212.         a = array.array(self.typecode, self.example[::-1])
  213.         b = a
  214.         a += array.array(self.typecode, 2 * self.example)
  215.         self.assert_(a is b)
  216.         self.assertEqual(a, array.array(self.typecode, self.example[::-1] + 2 * self.example))
  217.         b = array.array(self.badtypecode())
  218.         self.assertRaises(TypeError, a.__add__, b)
  219.         self.assertRaises(TypeError, a.__iadd__, 'bad')
  220.  
  221.     
  222.     def test_mul(self):
  223.         a = 5 * array.array(self.typecode, self.example)
  224.         self.assertEqual(a, array.array(self.typecode, 5 * self.example))
  225.         a = array.array(self.typecode, self.example) * 5
  226.         self.assertEqual(a, array.array(self.typecode, self.example * 5))
  227.         a = 0 * array.array(self.typecode, self.example)
  228.         self.assertEqual(a, array.array(self.typecode))
  229.         a = -1 * array.array(self.typecode, self.example)
  230.         self.assertEqual(a, array.array(self.typecode))
  231.         self.assertRaises(TypeError, a.__mul__, 'bad')
  232.  
  233.     
  234.     def test_imul(self):
  235.         a = array.array(self.typecode, self.example)
  236.         b = a
  237.         a *= 5
  238.         self.assert_(a is b)
  239.         self.assertEqual(a, array.array(self.typecode, 5 * self.example))
  240.         a *= 0
  241.         self.assert_(a is b)
  242.         self.assertEqual(a, array.array(self.typecode))
  243.         a *= 1000
  244.         self.assert_(a is b)
  245.         self.assertEqual(a, array.array(self.typecode))
  246.         a *= -1
  247.         self.assert_(a is b)
  248.         self.assertEqual(a, array.array(self.typecode))
  249.         a = array.array(self.typecode, self.example)
  250.         a *= -1
  251.         self.assertEqual(a, array.array(self.typecode))
  252.         self.assertRaises(TypeError, a.__imul__, 'bad')
  253.  
  254.     
  255.     def test_getitem(self):
  256.         a = array.array(self.typecode, self.example)
  257.         self.assertEntryEqual(a[0], self.example[0])
  258.         self.assertEntryEqual(a[0x0L], self.example[0])
  259.         self.assertEntryEqual(a[-1], self.example[-1])
  260.         self.assertEntryEqual(a[-0x1L], self.example[-1])
  261.         self.assertEntryEqual(a[len(self.example) - 1], self.example[-1])
  262.         self.assertEntryEqual(a[-len(self.example)], self.example[0])
  263.         self.assertRaises(TypeError, a.__getitem__)
  264.         self.assertRaises(IndexError, a.__getitem__, len(self.example))
  265.         self.assertRaises(IndexError, a.__getitem__, -len(self.example) - 1)
  266.  
  267.     
  268.     def test_setitem(self):
  269.         a = array.array(self.typecode, self.example)
  270.         a[0] = a[-1]
  271.         self.assertEntryEqual(a[0], a[-1])
  272.         a = array.array(self.typecode, self.example)
  273.         a[0x0L] = a[-1]
  274.         self.assertEntryEqual(a[0], a[-1])
  275.         a = array.array(self.typecode, self.example)
  276.         a[-1] = a[0]
  277.         self.assertEntryEqual(a[0], a[-1])
  278.         a = array.array(self.typecode, self.example)
  279.         a[-0x1L] = a[0]
  280.         self.assertEntryEqual(a[0], a[-1])
  281.         a = array.array(self.typecode, self.example)
  282.         a[len(self.example) - 1] = a[0]
  283.         self.assertEntryEqual(a[0], a[-1])
  284.         a = array.array(self.typecode, self.example)
  285.         a[-len(self.example)] = a[-1]
  286.         self.assertEntryEqual(a[0], a[-1])
  287.         self.assertRaises(TypeError, a.__setitem__)
  288.         self.assertRaises(TypeError, a.__setitem__, None)
  289.         self.assertRaises(TypeError, a.__setitem__, 0, None)
  290.         self.assertRaises(IndexError, a.__setitem__, len(self.example), self.example[0])
  291.         self.assertRaises(IndexError, a.__setitem__, -len(self.example) - 1, self.example[0])
  292.  
  293.     
  294.     def test_delitem(self):
  295.         a = array.array(self.typecode, self.example)
  296.         del a[0]
  297.         self.assertEqual(a, array.array(self.typecode, self.example[1:]))
  298.         a = array.array(self.typecode, self.example)
  299.         del a[-1]
  300.         self.assertEqual(a, array.array(self.typecode, self.example[:-1]))
  301.         a = array.array(self.typecode, self.example)
  302.         del a[len(self.example) - 1]
  303.         self.assertEqual(a, array.array(self.typecode, self.example[:-1]))
  304.         a = array.array(self.typecode, self.example)
  305.         del a[-len(self.example)]
  306.         self.assertEqual(a, array.array(self.typecode, self.example[1:]))
  307.         self.assertRaises(TypeError, a.__delitem__)
  308.         self.assertRaises(TypeError, a.__delitem__, None)
  309.         self.assertRaises(IndexError, a.__delitem__, len(self.example))
  310.         self.assertRaises(IndexError, a.__delitem__, -len(self.example) - 1)
  311.  
  312.     
  313.     def test_getslice(self):
  314.         a = array.array(self.typecode, self.example)
  315.         self.assertEqual(a[:], a)
  316.         self.assertEqual(a[1:], array.array(self.typecode, self.example[1:]))
  317.         self.assertEqual(a[:1], array.array(self.typecode, self.example[:1]))
  318.         self.assertEqual(a[:-1], array.array(self.typecode, self.example[:-1]))
  319.         self.assertEqual(a[-1:], array.array(self.typecode, self.example[-1:]))
  320.         self.assertEqual(a[-1:-1], array.array(self.typecode))
  321.         self.assertEqual(a[1000:], array.array(self.typecode))
  322.         self.assertEqual(a[-1000:], a)
  323.         self.assertEqual(a[:1000], a)
  324.         self.assertEqual(a[:-1000], array.array(self.typecode))
  325.         self.assertEqual(a[-1000:1000], a)
  326.         self.assertEqual(a[2000:1000], array.array(self.typecode))
  327.  
  328.     
  329.     def test_setslice(self):
  330.         a = array.array(self.typecode, self.example)
  331.         a[:1] = a
  332.         self.assertEqual(a, array.array(self.typecode, self.example + self.example[1:]))
  333.         a = array.array(self.typecode, self.example)
  334.         a[:-1] = a
  335.         self.assertEqual(a, array.array(self.typecode, self.example + self.example[-1:]))
  336.         a = array.array(self.typecode, self.example)
  337.         a[-1:] = a
  338.         self.assertEqual(a, array.array(self.typecode, self.example[:-1] + self.example))
  339.         a = array.array(self.typecode, self.example)
  340.         a[1:] = a
  341.         self.assertEqual(a, array.array(self.typecode, self.example[:1] + self.example))
  342.         a = array.array(self.typecode, self.example)
  343.         a[1:-1] = a
  344.         self.assertEqual(a, array.array(self.typecode, self.example[:1] + self.example + self.example[-1:]))
  345.         a = array.array(self.typecode, self.example)
  346.         a[1000:] = a
  347.         self.assertEqual(a, array.array(self.typecode, 2 * self.example))
  348.         a = array.array(self.typecode, self.example)
  349.         a[-1000:] = a
  350.         self.assertEqual(a, array.array(self.typecode, self.example))
  351.         a = array.array(self.typecode, self.example)
  352.         a[:1000] = a
  353.         self.assertEqual(a, array.array(self.typecode, self.example))
  354.         a = array.array(self.typecode, self.example)
  355.         a[:-1000] = a
  356.         self.assertEqual(a, array.array(self.typecode, 2 * self.example))
  357.         a = array.array(self.typecode, self.example)
  358.         a[1:0] = a
  359.         self.assertEqual(a, array.array(self.typecode, self.example[:1] + self.example + self.example[1:]))
  360.         a = array.array(self.typecode, self.example)
  361.         a[2000:1000] = a
  362.         self.assertEqual(a, array.array(self.typecode, 2 * self.example))
  363.         a = array.array(self.typecode, self.example)
  364.         self.assertRaises(TypeError, a.__setslice__, 0, 0, None)
  365.         self.assertRaises(TypeError, a.__setitem__, slice(0, 1), None)
  366.         b = array.array(self.badtypecode())
  367.         self.assertRaises(TypeError, a.__setslice__, 0, 0, b)
  368.         self.assertRaises(TypeError, a.__setitem__, slice(0, 1), b)
  369.  
  370.     
  371.     def test_index(self):
  372.         example = 2 * self.example
  373.         a = array.array(self.typecode, example)
  374.         self.assertRaises(TypeError, a.index)
  375.         for x in example:
  376.             self.assertEqual(a.index(x), example.index(x))
  377.         
  378.         self.assertRaises(ValueError, a.index, None)
  379.         self.assertRaises(ValueError, a.index, self.outside)
  380.  
  381.     
  382.     def test_count(self):
  383.         example = 2 * self.example
  384.         a = array.array(self.typecode, example)
  385.         self.assertRaises(TypeError, a.count)
  386.         for x in example:
  387.             self.assertEqual(a.count(x), example.count(x))
  388.         
  389.         self.assertEqual(a.count(self.outside), 0)
  390.         self.assertEqual(a.count(None), 0)
  391.  
  392.     
  393.     def test_remove(self):
  394.         for x in self.example:
  395.             example = 2 * self.example
  396.             a = array.array(self.typecode, example)
  397.             pos = example.index(x)
  398.             example2 = example[:pos] + example[pos + 1:]
  399.             a.remove(x)
  400.             self.assertEqual(a, array.array(self.typecode, example2))
  401.         
  402.         a = array.array(self.typecode, self.example)
  403.         self.assertRaises(ValueError, a.remove, self.outside)
  404.         self.assertRaises(ValueError, a.remove, None)
  405.  
  406.     
  407.     def test_pop(self):
  408.         a = array.array(self.typecode)
  409.         self.assertRaises(IndexError, a.pop)
  410.         a = array.array(self.typecode, 2 * self.example)
  411.         self.assertRaises(TypeError, a.pop, 42, 42)
  412.         self.assertRaises(TypeError, a.pop, None)
  413.         self.assertRaises(IndexError, a.pop, len(a))
  414.         self.assertRaises(IndexError, a.pop, -len(a) - 1)
  415.         self.assertEntryEqual(a.pop(0), self.example[0])
  416.         self.assertEqual(a, array.array(self.typecode, self.example[1:] + self.example))
  417.         self.assertEntryEqual(a.pop(1), self.example[2])
  418.         self.assertEqual(a, array.array(self.typecode, self.example[1:2] + self.example[3:] + self.example))
  419.         self.assertEntryEqual(a.pop(0), self.example[1])
  420.         self.assertEntryEqual(a.pop(), self.example[-1])
  421.         self.assertEqual(a, array.array(self.typecode, self.example[3:] + self.example[:-1]))
  422.  
  423.     
  424.     def test_reverse(self):
  425.         a = array.array(self.typecode, self.example)
  426.         self.assertRaises(TypeError, a.reverse, 42)
  427.         a.reverse()
  428.         self.assertEqual(a, array.array(self.typecode, self.example[::-1]))
  429.  
  430.     
  431.     def test_extend(self):
  432.         a = array.array(self.typecode, self.example)
  433.         self.assertRaises(TypeError, a.extend)
  434.         a.extend(array.array(self.typecode, self.example[::-1]))
  435.         self.assertEqual(a, array.array(self.typecode, self.example + self.example[::-1]))
  436.         b = array.array(self.badtypecode())
  437.         self.assertRaises(TypeError, a.extend, b)
  438.         a = array.array(self.typecode, self.example)
  439.         a.extend(self.example[::-1])
  440.         self.assertEqual(a, array.array(self.typecode, self.example + self.example[::-1]))
  441.  
  442.     
  443.     def test_constructor_with_iterable_argument(self):
  444.         a = array.array(self.typecode, iter(self.example))
  445.         b = array.array(self.typecode, self.example)
  446.         self.assertEqual(a, b)
  447.         self.assertRaises(TypeError, array.array, self.typecode, 10)
  448.         
  449.         class A:
  450.             
  451.             def __iter__(self):
  452.                 raise UnicodeError
  453.  
  454.  
  455.         self.assertRaises(UnicodeError, array.array, self.typecode, A())
  456.         
  457.         def B():
  458.             raise UnicodeError
  459.             yield None
  460.  
  461.         self.assertRaises(UnicodeError, array.array, self.typecode, B())
  462.  
  463.     
  464.     def test_coveritertraverse(self):
  465.         
  466.         try:
  467.             import gc as gc
  468.         except ImportError:
  469.             return None
  470.  
  471.         a = array.array(self.typecode)
  472.         l = [
  473.             iter(a)]
  474.         l.append(l)
  475.         gc.collect()
  476.  
  477.     
  478.     def test_buffer(self):
  479.         a = array.array(self.typecode, self.example)
  480.         b = buffer(a)
  481.         self.assertEqual(b[0], a.tostring()[0])
  482.  
  483.     
  484.     def test_weakref(self):
  485.         s = array.array(self.typecode, self.example)
  486.         p = proxy(s)
  487.         self.assertEqual(p.tostring(), s.tostring())
  488.         s = None
  489.         self.assertRaises(ReferenceError, len, p)
  490.  
  491.     
  492.     def test_bug_782369(self):
  493.         import sys as sys
  494.         if hasattr(sys, 'getrefcount'):
  495.             for i in range(10):
  496.                 b = array.array('B', range(64))
  497.             
  498.             rc = sys.getrefcount(10)
  499.             for i in range(10):
  500.                 b = array.array('B', range(64))
  501.             
  502.             self.assertEqual(rc, sys.getrefcount(10))
  503.         
  504.  
  505.  
  506.  
  507. class StringTest(BaseTest):
  508.     
  509.     def test_setitem(self):
  510.         super(StringTest, self).test_setitem()
  511.         a = array.array(self.typecode, self.example)
  512.         self.assertRaises(TypeError, a.__setitem__, 0, self.example[:2])
  513.  
  514.  
  515.  
  516. class CharacterTest(StringTest):
  517.     typecode = 'c'
  518.     example = '\x01azAZ\x00\xfe'
  519.     smallerexample = '\x01azAY\x00\xfe'
  520.     biggerexample = '\x01azAZ\x00\xff'
  521.     outside = '3'
  522.     minitemsize = 1
  523.     
  524.     def test_subbclassing(self):
  525.         
  526.         class EditableString(array.array):
  527.             
  528.             def __new__(cls, s, *args, **kwargs):
  529.                 return array.array.__new__(cls, 'c', s)
  530.  
  531.             
  532.             def __init__(self, s, color = 'blue'):
  533.                 array.array.__init__(self, 'c', s)
  534.                 self.color = color
  535.  
  536.             
  537.             def strip(self):
  538.                 self[:] = array.array('c', self.tostring().strip())
  539.  
  540.             
  541.             def __repr__(self):
  542.                 return 'EditableString(%r)' % self.tostring()
  543.  
  544.  
  545.         s = EditableString('\ttest\r\n')
  546.         s.strip()
  547.         self.assertEqual(s.tostring(), 'test')
  548.         self.assertEqual(s.color, 'blue')
  549.         s.color = 'red'
  550.         self.assertEqual(s.color, 'red')
  551.         self.assertEqual(s.__dict__.keys(), [
  552.             'color'])
  553.  
  554.     
  555.     def test_nounicode(self):
  556.         a = array.array(self.typecode, self.example)
  557.         self.assertRaises(ValueError, a.fromunicode, unicode(''))
  558.         self.assertRaises(ValueError, a.tounicode)
  559.  
  560.  
  561. tests.append(CharacterTest)
  562. if test_support.have_unicode:
  563.     
  564.     class UnicodeTest(StringTest):
  565.         typecode = 'u'
  566.         example = unicode('\\x01\\u263a\\x00\\ufeff', 'unicode-escape')
  567.         smallerexample = unicode('\\x01\\u263a\\x00\\ufefe', 'unicode-escape')
  568.         biggerexample = unicode('\\x01\\u263a\\x01\\ufeff', 'unicode-escape')
  569.         outside = unicode('3')
  570.         minitemsize = 2
  571.         
  572.         def test_unicode(self):
  573.             self.assertRaises(TypeError, array.array, 'b', unicode('foo', 'ascii'))
  574.             a = array.array('u', unicode('\\xa0\\xc2\\u1234', 'unicode-escape'))
  575.             a.fromunicode(unicode(' ', 'ascii'))
  576.             a.fromunicode(unicode('', 'ascii'))
  577.             a.fromunicode(unicode('', 'ascii'))
  578.             a.fromunicode(unicode('\\x11abc\\xff\\u1234', 'unicode-escape'))
  579.             s = a.tounicode()
  580.             self.assertEqual(s, unicode('\\xa0\\xc2\\u1234 \\x11abc\\xff\\u1234', 'unicode-escape'))
  581.             s = unicode('\\x00="\\\'a\\\\b\\x80\\xff\\u0000\\u0001\\u1234', 'unicode-escape')
  582.             a = array.array('u', s)
  583.             self.assertEqual(repr(a), 'array(\'u\', u\'\\x00="\\\'a\\\\b\\x80\\xff\\x00\\x01\\u1234\')')
  584.             self.assertRaises(TypeError, a.fromunicode)
  585.  
  586.  
  587.     tests.append(UnicodeTest)
  588.  
  589.  
  590. class NumberTest(BaseTest):
  591.     
  592.     def test_extslice(self):
  593.         a = array.array(self.typecode, range(5))
  594.         self.assertEqual(a[::], a)
  595.         self.assertEqual(a[::2], array.array(self.typecode, [
  596.             0,
  597.             2,
  598.             4]))
  599.         self.assertEqual(a[1::2], array.array(self.typecode, [
  600.             1,
  601.             3]))
  602.         self.assertEqual(a[::-1], array.array(self.typecode, [
  603.             4,
  604.             3,
  605.             2,
  606.             1,
  607.             0]))
  608.         self.assertEqual(a[::-2], array.array(self.typecode, [
  609.             4,
  610.             2,
  611.             0]))
  612.         self.assertEqual(a[3::-2], array.array(self.typecode, [
  613.             3,
  614.             1]))
  615.         self.assertEqual(a[-100:100:], a)
  616.         self.assertEqual(a[100:-100:-1], a[::-1])
  617.         self.assertEqual(a[-0x64L:0x64L:0x2L], array.array(self.typecode, [
  618.             0,
  619.             2,
  620.             4]))
  621.         self.assertEqual(a[1000:2000:2], array.array(self.typecode, []))
  622.         self.assertEqual(a[-1000:-2000:-2], array.array(self.typecode, []))
  623.  
  624.     
  625.     def test_delslice(self):
  626.         a = array.array(self.typecode, range(5))
  627.         del a[::2]
  628.         self.assertEqual(a, array.array(self.typecode, [
  629.             1,
  630.             3]))
  631.         a = array.array(self.typecode, range(5))
  632.         del a[1::2]
  633.         self.assertEqual(a, array.array(self.typecode, [
  634.             0,
  635.             2,
  636.             4]))
  637.         a = array.array(self.typecode, range(5))
  638.         del a[1::-2]
  639.         self.assertEqual(a, array.array(self.typecode, [
  640.             0,
  641.             2,
  642.             3,
  643.             4]))
  644.         a = array.array(self.typecode, range(10))
  645.         del a[::1000]
  646.         self.assertEqual(a, array.array(self.typecode, [
  647.             1,
  648.             2,
  649.             3,
  650.             4,
  651.             5,
  652.             6,
  653.             7,
  654.             8,
  655.             9]))
  656.  
  657.     
  658.     def test_assignment(self):
  659.         a = array.array(self.typecode, range(10))
  660.         a[::2] = array.array(self.typecode, [
  661.             42] * 5)
  662.         self.assertEqual(a, array.array(self.typecode, [
  663.             42,
  664.             1,
  665.             42,
  666.             3,
  667.             42,
  668.             5,
  669.             42,
  670.             7,
  671.             42,
  672.             9]))
  673.         a = array.array(self.typecode, range(10))
  674.         a[::-4] = array.array(self.typecode, [
  675.             10] * 3)
  676.         self.assertEqual(a, array.array(self.typecode, [
  677.             0,
  678.             10,
  679.             2,
  680.             3,
  681.             4,
  682.             10,
  683.             6,
  684.             7,
  685.             8,
  686.             10]))
  687.         a = array.array(self.typecode, range(4))
  688.         a[::-1] = a
  689.         self.assertEqual(a, array.array(self.typecode, [
  690.             3,
  691.             2,
  692.             1,
  693.             0]))
  694.         a = array.array(self.typecode, range(10))
  695.         b = a[:]
  696.         c = a[:]
  697.         ins = array.array(self.typecode, range(2))
  698.         a[2:3] = ins
  699.         b[slice(2, 3)] = ins
  700.         c[2:3:] = ins
  701.  
  702.     
  703.     def test_iterationcontains(self):
  704.         a = array.array(self.typecode, range(10))
  705.         self.assertEqual(list(a), range(10))
  706.         b = array.array(self.typecode, [
  707.             20])
  708.         self.assertEqual(a[-1] in a, True)
  709.         self.assertEqual(b[0] not in a, True)
  710.  
  711.     
  712.     def check_overflow(self, lower, upper):
  713.         a = array.array(self.typecode, [
  714.             lower])
  715.         a[0] = lower
  716.         self.assertRaises(OverflowError, array.array, self.typecode, [
  717.             lower - 1])
  718.         self.assertRaises(OverflowError, a.__setitem__, 0, lower - 1)
  719.         a = array.array(self.typecode, [
  720.             upper])
  721.         a[0] = upper
  722.         self.assertRaises(OverflowError, array.array, self.typecode, [
  723.             upper + 1])
  724.         self.assertRaises(OverflowError, a.__setitem__, 0, upper + 1)
  725.  
  726.     
  727.     def test_subclassing(self):
  728.         typecode = self.typecode
  729.         
  730.         class ExaggeratingArray(array.array):
  731.             __slots__ = [
  732.                 'offset']
  733.             
  734.             def __new__(cls, typecode, data, offset):
  735.                 return array.array.__new__(cls, typecode, data)
  736.  
  737.             
  738.             def __init__(self, typecode, data, offset):
  739.                 self.offset = offset
  740.  
  741.             
  742.             def __getitem__(self, i):
  743.                 return array.array.__getitem__(self, i) + self.offset
  744.  
  745.  
  746.         a = ExaggeratingArray(self.typecode, [
  747.             3,
  748.             6,
  749.             7,
  750.             11], 4)
  751.         self.assertEntryEqual(a[0], 7)
  752.         self.assertRaises(AttributeError, setattr, a, 'color', 'blue')
  753.  
  754.  
  755.  
  756. class SignedNumberTest(NumberTest):
  757.     example = [
  758.         -1,
  759.         0,
  760.         1,
  761.         42,
  762.         127]
  763.     smallerexample = [
  764.         -1,
  765.         0,
  766.         1,
  767.         42,
  768.         126]
  769.     biggerexample = [
  770.         -1,
  771.         0,
  772.         1,
  773.         43,
  774.         127]
  775.     outside = 23
  776.     
  777.     def test_overflow(self):
  778.         a = array.array(self.typecode)
  779.         lower = -1 * long(pow(2, a.itemsize * 8 - 1))
  780.         upper = long(pow(2, a.itemsize * 8 - 1)) - 0x1L
  781.         self.check_overflow(lower, upper)
  782.  
  783.  
  784.  
  785. class UnsignedNumberTest(NumberTest):
  786.     example = [
  787.         0,
  788.         1,
  789.         17,
  790.         23,
  791.         42,
  792.         255]
  793.     smallerexample = [
  794.         0,
  795.         1,
  796.         17,
  797.         23,
  798.         42,
  799.         254]
  800.     biggerexample = [
  801.         0,
  802.         1,
  803.         17,
  804.         23,
  805.         43,
  806.         255]
  807.     outside = 170
  808.     
  809.     def test_overflow(self):
  810.         a = array.array(self.typecode)
  811.         lower = 0
  812.         upper = long(pow(2, a.itemsize * 8)) - 0x1L
  813.         self.check_overflow(lower, upper)
  814.  
  815.  
  816.  
  817. class ByteTest(SignedNumberTest):
  818.     typecode = 'b'
  819.     minitemsize = 1
  820.  
  821. tests.append(ByteTest)
  822.  
  823. class UnsignedByteTest(UnsignedNumberTest):
  824.     typecode = 'B'
  825.     minitemsize = 1
  826.  
  827. tests.append(UnsignedByteTest)
  828.  
  829. class ShortTest(SignedNumberTest):
  830.     typecode = 'h'
  831.     minitemsize = 2
  832.  
  833. tests.append(ShortTest)
  834.  
  835. class UnsignedShortTest(UnsignedNumberTest):
  836.     typecode = 'H'
  837.     minitemsize = 2
  838.  
  839. tests.append(UnsignedShortTest)
  840.  
  841. class IntTest(SignedNumberTest):
  842.     typecode = 'i'
  843.     minitemsize = 2
  844.  
  845. tests.append(IntTest)
  846.  
  847. class UnsignedIntTest(UnsignedNumberTest):
  848.     typecode = 'I'
  849.     minitemsize = 2
  850.  
  851. tests.append(UnsignedIntTest)
  852.  
  853. class LongTest(SignedNumberTest):
  854.     typecode = 'l'
  855.     minitemsize = 4
  856.  
  857. tests.append(LongTest)
  858.  
  859. class UnsignedLongTest(UnsignedNumberTest):
  860.     typecode = 'L'
  861.     minitemsize = 4
  862.  
  863. tests.append(UnsignedLongTest)
  864.  
  865. class FPTest(NumberTest):
  866.     example = [
  867.         -42.0,
  868.         0,
  869.         42,
  870.         100000.0,
  871.         -10000000000.0]
  872.     smallerexample = [
  873.         -42.0,
  874.         0,
  875.         42,
  876.         100000.0,
  877.         -20000000000.0]
  878.     biggerexample = [
  879.         -42.0,
  880.         0,
  881.         42,
  882.         100000.0,
  883.         10000000000.0]
  884.     outside = 23
  885.     
  886.     def assertEntryEqual(self, entry1, entry2):
  887.         self.assertAlmostEqual(entry1, entry2)
  888.  
  889.     
  890.     def test_byteswap(self):
  891.         a = array.array(self.typecode, self.example)
  892.         self.assertRaises(TypeError, a.byteswap, 42)
  893.         if a.itemsize in (1, 2, 4, 8):
  894.             b = array.array(self.typecode, self.example)
  895.             b.byteswap()
  896.             if a.itemsize == 1:
  897.                 self.assertEqual(a, b)
  898.             else:
  899.                 self.assertNotEqual(a.tostring(), b.tostring())
  900.             b.byteswap()
  901.             self.assertEqual(a, b)
  902.         
  903.  
  904.  
  905.  
  906. class FloatTest(FPTest):
  907.     typecode = 'f'
  908.     minitemsize = 4
  909.  
  910. tests.append(FloatTest)
  911.  
  912. class DoubleTest(FPTest):
  913.     typecode = 'd'
  914.     minitemsize = 8
  915.  
  916. tests.append(DoubleTest)
  917.  
  918. def test_main(verbose = None):
  919.     import sys
  920.     test_support.run_unittest(*tests)
  921.     if verbose and hasattr(sys, 'gettotalrefcount'):
  922.         import gc
  923.         counts = [
  924.             None] * 5
  925.         for i in xrange(len(counts)):
  926.             test_support.run_unittest(*tests)
  927.             gc.collect()
  928.             counts[i] = sys.gettotalrefcount()
  929.         
  930.         print counts
  931.     
  932.  
  933. if __name__ == '__main__':
  934.     test_main(verbose = True)
  935.  
  936.